﻿#region 引用
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Media;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;
using 时钟壁纸应用.主要窗口;
#endregion
namespace 时钟壁纸应用
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class 桌面主时钟 : Window
    {
        #region 实例化类
        主要窗口.窗口状态 控件 = new 主要窗口.窗口状态();
        主要窗口.时钟状态 时钟 = new 主要窗口.时钟状态();
        主要窗口.用户设置 配置 = new 主要窗口.用户设置();
        主要窗口.时间区间 时间段 = new 主要窗口.时间区间();
        主要窗口.设置文件 设置 = new 设置文件();
        /// <summary>
        /// 用于检测或修改壁纸信息
        /// </summary>
        /// <param name="uAction"></param>
        /// <param name="uParam"></param>
        /// <param name="lpvParam"></param>
        /// <param name="init"></param>
        /// <returns></returns>
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern bool SystemParametersInfo(uint uAction, uint uParam, StringBuilder lpvParam, uint init);
        #endregion
        #region 构造方法
        public 桌面主时钟()
        {
            InitializeComponent();

            //以下的设定是临时设定
            
            配置.壁纸_文件夹路径 = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures) + "\\壁纸\\";
            时钟.总成状态 = 主要窗口.时钟状态.全局显示.开;
            时钟.提醒状态 = 时钟状态.闹钟状态.闹钟;
          
            // 以下是必要设定
            设置.打开设置(配置,时间段);
            设定窗口位置();
            启动线程(设定计时器);
            启动线程(设定慢速计时器);
            时钟.总成状态 = 时钟状态.全局显示.关;
            时钟.更新状态 = 时钟状态.更新模式.未触发;
 
        }
        #endregion
        #region 线程管理器
        /// <summary>
        /// 启动一个新线程来运行
        /// </summary>
        /// <param name="要运行的方法">要运行的无参方法名称</param>
        public void 启动线程(ThreadStart 要运行的方法)
        {
            if (控件.运行 == false) { return; }
            Thread 新线程 = new Thread(要运行的方法);
            新线程.Start();
            时钟.线程池.Add(新线程);
        }
        /// <summary>
        /// 取出已建立的线程数量
        /// </summary>
        /// <returns></returns>
        public int 取线程数()
        {
            return 时钟.线程池.Count;
        }
        #endregion
        #region 计时器模块
        /// <summary>
        /// 设定计时器，并每隔一段时间刷新一次
        /// </summary>
        public void 设定计时器()
        {
            while (DateTime.Now.Millisecond != 0) //强制等待为正好1秒
            {
            }
            while (true)
            {
                if (控件.运行 == false) { return; }
                设定计时器刷新间隔();
                计时器响应();
                Thread.Sleep(时钟.当前刷新间隔);
            }
        }
        /// <summary>
        /// 用与更新计时器当时钟处于不同状态时应该具有的刷新间隔时间
        /// </summary>
        public void 设定计时器刷新间隔()
        {
            if (时钟.总成状态 == 时钟状态.全局显示.开) { 时钟.当前刷新间隔 = 配置.刷新间隔; }
            if (时钟.总成状态 == 时钟状态.全局显示.关) { 时钟.当前刷新间隔 = 配置.后台刷新间隔; }

        }
        /// <summary>
        /// 设定到达设定的间隔时间后需要执行的模块，一般消耗较小
        /// </summary>
        public void 计时器响应()
        {
            日志.输出("计时器正在执行响应");
            if (控件.运行 == false) { return; }
            判断半整点();
            更新总成显隐状态();
            更新时间();
            更新时间段名();
            更新快捷按钮状态();
            设定窗口位置(new object());
            倒计时判断();
        
        }
        /// <summary>
        /// 存放的是一些内存消耗较大的模块，他们会以更久的时间更新一次
        /// </summary>
        public void 设定慢速计时器()
        {
            while (true)
            {
                if (控件.运行 == false) { return; }
                启动线程(更新壁纸);
                Thread.Sleep(配置.非即时模块刷新间隔);
            }
           
        }
        #endregion
        #region 半点整点显时模块
        public void 判断半整点()
        {

            if (时钟.更新状态 == 时钟状态.更新模式.手动触发) { return; } //如果在进入之前已经是手动触发状态那么就跳过
            #region 在时间区间时显示
            if (System.DateTime.Now.Minute == 59 || System.DateTime.Now.Minute == 29)
            {
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
                {
                时.Text = System.DateTime.Now.ToString("HH");
                分.Text = System.DateTime.Now.ToString("mm");
                秒.Text = System.DateTime.Now.ToString("ss");
                });
                if (System.DateTime.Now.Second >= 29)
                {
                    时钟.总成状态 = 时钟状态.全局显示.开;
                    if (时钟.更新状态 == 时钟状态.更新模式.自动触发o倒计时与闹钟) { 时钟.更新状态 = 时钟状态.更新模式.自动触发o双重触发; }
                    if (时钟.更新状态 == 时钟状态.更新模式.未触发) { 时钟.更新状态 = 时钟状态.更新模式.自动触发o半时与整时; }
                    return;
                }

            }
            if (System.DateTime.Now.Minute == 30 || System.DateTime.Now.Minute == 00)
            {
                if (System.DateTime.Now.Second <= 30)
                {
                    时钟.总成状态 = 时钟状态.全局显示.开;
                    if (时钟.更新状态 == 时钟状态.更新模式.自动触发o倒计时与闹钟) { 时钟.更新状态 = 时钟状态.更新模式.自动触发o双重触发; }
                    if (时钟.更新状态 == 时钟状态.更新模式.未触发) { 时钟.更新状态 = 时钟状态.更新模式.自动触发o半时与整时; }
                    return;
                }
            }
            #endregion
            #region 关闭逻辑
            if (时钟.更新状态 == 时钟状态.更新模式.自动触发o半时与整时)
            {
                时钟.更新状态 = 时钟状态.更新模式.未触发;
                时钟.总成状态 = 时钟状态.全局显示.关;
                return;
            } //是自己触发的那么直接关闭
            if (时钟.更新状态 == 时钟状态.更新模式.自动触发o双重触发) 
            {
                时钟.更新状态 = 时钟状态.更新模式.自动触发o倒计时与闹钟;
                if (时钟.提醒状态 == 时钟状态.闹钟状态.提醒 || 时钟.提醒状态 == 时钟状态.闹钟状态.闹钟 || 时钟.提醒状态 == 时钟状态.闹钟状态.未设定)
                {
                    时钟.总成状态 = 时钟状态.全局显示.关;
                }
                    return;
            } //双重触发时删掉自己的触发状态，不执行界面操作
            if (时钟.更新状态 == 时钟状态.更新模式.手动触发) 
            {
                return;
            } //手动触发时保留不做任何操作
            #endregion

        }

        #endregion
        #region UI更新模块
        public void 更新总成显隐状态()
        {
            //只与总成状态关联
            this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
            {
                if (时钟.总成状态 == 时钟状态.全局显示.开) { this.Visibility = Visibility.Visible; }
                if (时钟.总成状态 == 时钟状态.全局显示.关) { this.Visibility = Visibility.Hidden; }
            });
        }
        public void 更新快捷按钮状态()
        {
            //只与快捷按钮关联
            this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
            {
                if (时钟.更新状态 == 时钟状态.更新模式.手动触发)
                {
                    快捷按钮.Visibility = Visibility.Visible;
                    return;
                } //是手动触发就保留
                if (时钟.更新状态 == 时钟状态.更新模式.自动触发o倒计时与闹钟 || 时钟.更新状态 == 时钟状态.更新模式.自动触发o双重触发)
                {
                    快捷按钮.Visibility = Visibility.Visible;
                    return;
                } //是倒计时也保留
  
                    快捷按钮.Visibility = Visibility.Hidden; //啥都没有就关闭
           
            });
            日志.输出(Enum.GetName(typeof(时钟状态.更新模式), 时钟.更新状态));

        }
        public void 更新时间段名()
        {
            if (时钟.总成状态 == 主要窗口.时钟状态.全局显示.关) { return; } //如果当前全局显示没有开启，则不更新时钟显示
            this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
            {
                时间区间.Text = 时间段.取当前时间区间(DateTime.Now.Hour);
            });
        }
        public void 更新时间()
        {
            if(时钟.总成状态 == 主要窗口.时钟状态.全局显示.关) { return; } //如果当前全局显示没有开启，则不更新时钟显示
            if(时钟.更新状态 == 时钟状态.更新模式.未触发) { 时钟.总成状态 = 时钟状态.全局显示.关; return; } // 如果现在更新状态是未触发，那么就将总成状态也关闭，也不再更新
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
                {
                    if (时钟.点状态 == 主要窗口.时钟状态.分隔符.显示)
                      {

                        日志.输出("点隐藏");
                        时针点.Visibility = Visibility.Hidden;
                        分针点.Visibility = Visibility.Hidden;
                        时钟.点状态 = 主要窗口.时钟状态.分隔符.隐藏;
                        return;
                      }
                    if (时钟.点状态 == 主要窗口.时钟状态.分隔符.隐藏)
                      {
                        日志.输出("点显示");
                        时针点.Visibility = Visibility.Visible;
                        分针点.Visibility = Visibility.Visible;
                        时.Text = System.DateTime.Now.ToString("HH");
                        分.Text = System.DateTime.Now.ToString("mm");
                        秒.Text = System.DateTime.Now.ToString("ss");
                        时钟.点状态 = 主要窗口.时钟状态.分隔符.显示;
                        return;
                    }
                 });
            

        }
        public void 设定窗口位置()
        {

            控件.屏幕宽度 = System.Windows.SystemParameters.PrimaryScreenWidth;
            控件.屏幕长度 = System.Windows.SystemParameters.PrimaryScreenHeight;
            this.ShowInTaskbar = false; //不在任务栏显示
            this.Top = 控件.屏幕长度 * 0.02;
            this.Left = 控件.屏幕宽度 - this.Width * 1.05;
            this.Topmost = true;            // 永在最上层

        }
        public void 设定窗口位置(object 更新)
        {
            this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
            {
                控件.屏幕宽度 = System.Windows.SystemParameters.PrimaryScreenWidth;
                控件.屏幕长度 = System.Windows.SystemParameters.PrimaryScreenHeight;
                // 若当前位置不正确就修改控件的位置
                if (Math.Round(控件.屏幕宽度) != Math.Round(System.Windows.SystemParameters.PrimaryScreenWidth) || Math.Round(控件.屏幕长度) != Math.Round(System.Windows.SystemParameters.PrimaryScreenHeight))
                {
                    this.ShowInTaskbar = false; //不在任务栏显示
                    this.Top = 控件.屏幕长度 * 0.02;
                    this.Left = 控件.屏幕宽度 - this.Width * 1.05;
                    this.Topmost = true;            // 永在最上层
                }
            });
        }
        #endregion
        #region 壁纸更新模块
        
        public void 更新壁纸()
        {
            // 判断用户设置的壁纸路径是否存在
            if (配置.壁纸_文件夹路径 == null){ 日志.输出("未设定壁纸路径"); return; }
            string 壁纸路径 = 配置.壁纸_文件夹路径;
            if (Directory.Exists(壁纸路径) == false)  { 日志.输出("指定壁纸路径不存在。已重置壁纸路径"); 配置.壁纸_文件夹路径 = null; return; }
            // 更新当前壁纸路径
            const uint SPI_GETDESKWALLPAPER = 0x0073;
            StringBuilder wallPaperPath = new StringBuilder(200);
            string 当前壁纸路径 = "";

            if (SystemParametersInfo(SPI_GETDESKWALLPAPER, 200, wallPaperPath, 0))
            {
                当前壁纸路径 = wallPaperPath.ToString();
                日志.输出("当前壁纸路径  = " + 当前壁纸路径);
            }
            //判断当前是否需要更换壁纸
            if (当前壁纸路径 == 壁纸路径 + 时间段.取当前时间区间(DateTime.Now.Hour) + ".jpg" || 当前壁纸路径 == 壁纸路径 + 时间段.取当前时间区间(DateTime.Now.Hour) + ".png")
            {
                日志.输出("无需更换壁纸");
                return;
            }
            //更换壁纸
            辅助类.壁纸 壁纸 = new 辅助类.壁纸();
            日志.输出($"搜索文件{壁纸路径 + 时间段.取当前时间区间(DateTime.Now.Hour) + ".jpg"}");
            if (File.Exists(壁纸路径 + 时间段.取当前时间区间(DateTime.Now.Hour) + ".jpg"))
            {
                壁纸.更换壁纸(壁纸路径 + 时间段.取当前时间区间(DateTime.Now.Hour) + ".jpg");
                日志.输出($"更换壁纸到{壁纸路径 + 时间段.取当前时间区间(DateTime.Now.Hour) + ".jpg"}");
            }
            if (File.Exists(壁纸路径 + 时间段.取当前时间区间(DateTime.Now.Hour) + ".png"))
            {
                壁纸.更换壁纸(壁纸路径 + 时间段.取当前时间区间(DateTime.Now.Hour) + ".png");
                日志.输出($"更换壁纸到{壁纸路径 + 时间段.取当前时间区间(DateTime.Now.Hour) + ".jpg"}");
            }


        }

        #endregion
        #region 倒计时模块
        public void 倒计时判断()
        {

            if (配置.闹钟_下次响铃时间.Subtract(DateTime.Now) < TimeSpan.FromSeconds(0) && 时钟.光标位置 != 时钟状态.光标状态.在选项上 && 配置.闹钟_模式 == 用户设置.闹钟模式.关闭)
            {
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
                {
                    定时器新建按钮.Text = "⏰";
                });
            }
            if (配置.闹钟_下次响铃时间.Subtract(DateTime.Now) <= TimeSpan.FromSeconds(60) && 配置.闹钟_下次响铃时间.Subtract(DateTime.Now) >= TimeSpan.FromSeconds(0) && 时钟.光标位置 != 时钟状态.光标状态.在选项上 && 配置.闹钟_模式 != 用户设置.闹钟模式.关闭)
            {
                //UI控制
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
                {
                    定时器新建按钮.Text = $"⏰!  {配置.闹钟_提醒内容} {配置.闹钟_下次响铃时间.Subtract(DateTime.Now).ToString(@"mm\:ss")}";
                    if (时钟.更新状态 == 时钟状态.更新模式.未触发) { 时钟.更新状态 = 时钟状态.更新模式.自动触发o倒计时与闹钟; }
                    if (时钟.更新状态 == 时钟状态.更新模式.自动触发o半时与整时) { 时钟.更新状态 = 时钟状态.更新模式.自动触发o双重触发; }
                    if (时钟.提醒状态 == 时钟状态.闹钟状态.提醒) { 时钟.提醒状态 = 时钟状态.闹钟状态.等待提醒; 时钟.总成状态 = 时钟状态.全局显示.开; }
                    if (时钟.提醒状态 == 时钟状态.闹钟状态.闹钟) { 时钟.提醒状态 = 时钟状态.闹钟状态.等待闹钟; 时钟.总成状态 = 时钟状态.全局显示.开; }
                    if (时钟.提醒状态 == 时钟状态.闹钟状态.等待提醒 && 时钟.总成状态 == 时钟状态.全局显示.关) {时钟.总成状态 = 时钟状态.全局显示.开; }
                    if (时钟.提醒状态 == 时钟状态.闹钟状态.等待闹钟 && 时钟.总成状态 == 时钟状态.全局显示.关) {时钟.总成状态 = 时钟状态.全局显示.开; }

                });
                //声音控制
                if (配置.闹钟_下次响铃时间.Subtract(DateTime.Now) < TimeSpan.FromSeconds(5) && 配置.闹钟_模式 == 用户设置.闹钟模式.仅提醒)
                {
                    启动线程(声音模块_仅提醒);
                }
                if (配置.闹钟_下次响铃时间.Subtract(DateTime.Now) < TimeSpan.FromSeconds(5) && 配置.闹钟_模式 == 用户设置.闹钟模式.循环闹钟)
                {
                    启动线程(声音模块_循环);
                }

               
                if (配置.闹钟_下次响铃时间.Subtract(DateTime.Now) <= TimeSpan.FromMilliseconds(配置.刷新间隔) && 时钟.光标位置 != 时钟状态.光标状态.在选项上 && 配置.闹钟_模式 != 用户设置.闹钟模式.关闭)
                {
                    this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
                    {
                        定时器新建按钮.Text = $"⏰";
                        if (时钟.更新状态 == 时钟状态.更新模式.自动触发o双重触发) { 时钟.更新状态 = 时钟状态.更新模式.自动触发o半时与整时; }
                        if (时钟.更新状态 == 时钟状态.更新模式.自动触发o倒计时与闹钟) { 时钟.更新状态 = 时钟状态.更新模式.未触发; }

                    });
                    return;
                }

                return;
            }

            if (配置.闹钟_下次响铃时间.Subtract(DateTime.Now) > TimeSpan.FromSeconds(0) && 时钟.光标位置 != 时钟状态.光标状态.在选项上 && 配置.闹钟_模式 != 用户设置.闹钟模式.关闭)
            {
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
                {
                    // 时间间隔计算
                    var 剩余时间 = 计算时间间隔(DateTime.Now, 配置.闹钟_下次响铃时间);
                    var 最初时间 = 配置.闹钟_设定闹钟时间;
                    double 原秒数 = 计算时间间隔(配置.闹钟_下次响铃时间, 最初时间).TotalSeconds;
                    double 现秒数 = 剩余时间.TotalSeconds;
                    double 分之数 = Math.Round(现秒数 / 原秒数 * 100, 1);
                    // 间隔计算结束
                    定时器新建按钮.Text = $"⏰ {配置.闹钟_提醒内容} {剩余时间.Hours}:{剩余时间.Minutes}:{剩余时间.Seconds} - {分之数}%";
                    if (时钟.更新状态 == 时钟状态.更新模式.未触发) { 时钟.更新状态 = 时钟状态.更新模式.自动触发o倒计时与闹钟; }
                    if (时钟.更新状态 == 时钟状态.更新模式.自动触发o半时与整时) { 时钟.更新状态 = 时钟状态.更新模式.自动触发o双重触发; }

                   
                });
                return;
            }



        }
        public void 声音模块_仅提醒()
        {
            Console.WriteLine(配置.闹钟_下次响铃时间.Subtract(DateTime.Now));
            if (配置.闹钟_下次响铃时间.Subtract(DateTime.Now) <= TimeSpan.FromMilliseconds(配置.刷新间隔) && 配置.闹钟_模式 == 用户设置.闹钟模式.仅提醒)
            {
                      
                    SoundPlayer player = new SoundPlayer();
                    player.SoundLocation = 配置.闹钟_铃声位置;
                    player.Load();
                    player.PlaySync();
        
            }

        }
        public void 声音模块_循环()
        {
            Console.WriteLine(配置.闹钟_下次响铃时间.Subtract(DateTime.Now));
            if (配置.闹钟_下次响铃时间.Subtract(DateTime.Now) <= TimeSpan.FromMilliseconds(配置.刷新间隔) && 配置.闹钟_模式 == 用户设置.闹钟模式.循环闹钟)
            {
                Thread thread = new Thread(启动提示窗);
                thread.SetApartmentState(ApartmentState.STA);
                thread.Start();

            }

        }
        public void 启动提示窗()
        {
            响铃窗口 响铃 = new 响铃窗口(配置.闹钟_铃声组);
            响铃.Show();
            System.Windows.Threading.Dispatcher.Run();
         

        }

        private TimeSpan 计算时间间隔(DateTime 开始时刻, DateTime 结束时刻)
        {
            TimeSpan 开始时间 = new TimeSpan(开始时刻.Ticks);
            TimeSpan 结束时间 = new TimeSpan(结束时刻.Ticks);
            TimeSpan ts = 开始时间.Subtract(结束时间).Duration();
            return ts;

        }


        #endregion
        #region 快捷键设定模块
        /// <summary>
        /// 用于初始化快捷键的设定
        /// </summary>
        public void 快捷键设定()
        {

            Hotkey.Regist(this, 配置.组合键, 配置.普通键, () =>
            {

                if (时钟.总成状态 ==  时钟状态.全局显示.开)
                {
                    时钟.总成状态 =  时钟状态.全局显示.关;
                    时钟.更新状态 = 时钟状态.更新模式.未触发;
                    this.Visibility = Visibility.Hidden;
                }
                else
                {
                    时钟.总成状态 = 时钟状态.全局显示.开;
                    时钟.更新状态 = 时钟状态.更新模式.手动触发;
                    this.Visibility = Visibility.Visible;
                    计时器响应();

                }

            });

            this.Visibility = Visibility.Hidden; //执行好设定后隐藏这个窗口


        }
        #endregion
        #region 系统事件
        private void 初始化快捷键(object sender, RoutedEventArgs e)
        {
            快捷键设定();
        }


        private void 定时器新建按钮_MouseMove(object sender, MouseEventArgs e)
        {
            Console.WriteLine("事件移进");
            时钟.光标位置 = 时钟状态.光标状态.在选项上;
            定时器新建按钮.Text = "⏰ 闹钟/主设定";


        }

        private void 定时器新建按钮_MouseLeave(object sender, MouseEventArgs e)
        {
            Console.WriteLine("事件移出");
            时钟.光标位置 = 时钟状态.光标状态.在选项外;

                定时器新建按钮.Text = "⏰";

        }

        private void 定时器新建按钮_MouseDown(object sender, MouseButtonEventArgs e)
        {

                配置设置 设置窗口 = new 配置设置(配置,时间段);
                设置窗口.Show();
                return;
      


        }

        private void 音乐欣赏按钮_MouseMove(object sender, MouseEventArgs e)
        {
            Console.WriteLine("音乐事件移进");
            时钟.光标位置 = 时钟状态.光标状态.在选项上;
            音乐欣赏按钮.Text = "🎵 循环播放器";
   
        }

        private void 音乐欣赏按钮_MouseLeave(object sender, MouseEventArgs e)
        {
            Console.WriteLine("事件移出");
            时钟.光标位置 = 时钟状态.光标状态.在选项外;
            音乐欣赏按钮.Text = "🎵";
        }

        private void 音乐欣赏按钮_MouseDown(object sender, MouseButtonEventArgs e)
        {
            if (控件.当前播放器 == null)
            {
                //当未启动播放器时的逻辑
                无缝播放器.MainWindow 播放器 = new 无缝播放器.MainWindow(控件);
                
                控件.播放器打开状态 = true;
                控件.当前播放器 = 播放器;
                控件.当前播放器.Show();
            }
            else
            {
                //当已经启动播放器时的逻辑
                控件.当前播放器.WindowState = WindowState.Normal;
                控件.当前播放器.Show();
            }



        }
        #endregion

        private void 待办事项按钮_MouseMove(object sender, MouseEventArgs e)
        {
            Console.WriteLine("音乐事件移进");
            时钟.光标位置 = 时钟状态.光标状态.在选项上;
            待办事项按钮.Text = "☑️ 任务";

        }

        private void 待办事项按钮_MouseDown(object sender, MouseButtonEventArgs e)
        {
            if (控件.待办事项打开状态 == false)
            {
                //当未启动待办窗口时的逻辑
                任务管理器.任务管理器侧边栏 待办窗 = new 任务管理器.任务管理器侧边栏();

                控件.待办事项打开状态 = true;
                控件.当前待办事项 = 待办窗;
                控件.当前待办事项.Show();
            }
            else
            {
                控件.待办事项打开状态 = false;
                
                    控件.当前待办事项.Close();
                控件.当前待办事项 = null;
                    return;
                }
           

            
        }

        private void 待办事项按钮_MouseLeave(object sender, MouseEventArgs e)
        {
            Console.WriteLine("事件移出");
            时钟.光标位置 = 时钟状态.光标状态.在选项外;
            待办事项按钮.Text = "☑️";
    
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            Console.WriteLine("准备结束主程序");
            时钟.总成状态 = 主要窗口.时钟状态.全局显示.关;
            控件.运行 = false;
            for (int i = 0; i < 3; i++)
            {
                foreach (var j in 时钟.线程池)
                {
                    j.Abort();
                }
                Console.WriteLine($"第{i}次内存清理");
                GC.Collect();
            }
        }
    }
}
